//package com.kz.bot.task;
//
//import com.kz.bot.config.TradeConfig;
//import com.kz.bot.constant.OrderState;
//import com.kz.bot.constant.Side;
//import com.kz.bot.model.Order;
//import com.kz.bot.model.OrderBook;
//import com.kz.bot.model.TradeRecord;
//import com.kz.bot.service.ApiService;
//import com.kz.bot.util.MathCalculationUtil;
//import lombok.RequiredArgsConstructor;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.commons.lang3.StringUtils;
//import org.springframework.boot.context.event.ApplicationReadyEvent;
//import org.springframework.context.event.EventListener;
//import org.springframework.stereotype.Component;
//
//import java.math.BigDecimal;
//import java.math.RoundingMode;
//import java.util.List;
//
//@Slf4j
//@Component
//@RequiredArgsConstructor
//public class BotTask3 {
//
//    private final TradeConfig config;
//    private final ApiService apiService;
//
//    // 当前卖出轮次，从0开始
//    private int sellCount = 0;
//    // 新增：交易手续费率 (例如0.08%)，请根据您的交易所费率进行调整
//    private final BigDecimal tradeFeeRate = new BigDecimal("0.0008");
//
//    @EventListener(ApplicationReadyEvent.class)
//    public void onReady() {
//        if (StringUtils.isBlank(config.getApiKey())
//                || StringUtils.isBlank(config.getApiSecret())
//                || StringUtils.isBlank(config.getApiPass())) {
//            throw new RuntimeException("ak sk pass 未配置,终止运行");
//        }
//
//        OrderBook book = new OrderBook();
//        BigDecimal step = config.getStepLength();
//        String instId = config.getInstId();
//        int priceScale = config.getPriceScale();
//        int volumeScale = config.getVolumeScale();
//        BigDecimal tradeVolume = config.getTradeVolume();
//        // 获取新的马丁格尔参数
//        BigDecimal volumeMartin = config.getVolumeMartin();
//        BigDecimal priceMartin = config.getPriceMartin();
//
//        BigDecimal costPrice = config.getCostPrice();
//        BigDecimal lastPrice = apiService.queryLastPrice(instId);
//        BigDecimal price = (costPrice != null) ? costPrice : lastPrice;
//
//        // 记录当前卖单id
//        List<Order> currentSellOrders = apiService.currentOrder(instId, Side.sell);
//        if (currentSellOrders.isEmpty()) {
//            // 当前卖单为空
//            BigDecimal instHoldVolume = apiService.queryAccountBalance(instId.replace("-USDT", ""));
//            log.info("当前币种余额:{},{}", instId, instHoldVolume);
//            if (instHoldVolume.compareTo(tradeVolume) < 0) {
//                log.error("当前币种初始持仓量小于单次成交量,{},当前可用余额:{},单次成交量:{}", instId, instHoldVolume, tradeVolume);
//            }
//
//            // 当前没有卖单 -> 挂初始卖单
//            book.currentSellOrder = apiService.placeOrder(instId, Side.sell, tradeVolume, price);
//            if (book.currentSellOrder == null) {
//                throw new RuntimeException("启动挂单失败");
//            }
//        } else {
//            if (currentSellOrders.size() > 1) {
//                throw new RuntimeException("该账户下该币种当前存在的卖单超过1个");
//            }
//            book.currentSellOrder = currentSellOrders.getFirst();
//        }
//
//        while (true) {
//            try {
//                // ==============================
//                // 1. 检查买单状态
//                // ==============================
//                if (book.getCurrentBuyOrder() != null) {
//                    Order currentBuyOrder = book.getCurrentBuyOrder();
//                    String buyOrderState = apiService.queryOrderStatus(instId, currentBuyOrder.getOrdId());
//
//                    if (OrderState.filled.name().equals(buyOrderState)) {
//                        log.info("买单成交，本轮周期结束，开始计算并再投资利润");
//
//                        // ===== 新增：利润计算与再投资逻辑（已考虑手续费） =====
//                        BigDecimal totalSellValue = book.sellHistory.stream()
//                                .map(t -> t.getPrice().multiply(t.getVolume()))
//                                .reduce(BigDecimal.ZERO, BigDecimal::add);
//
//                        BigDecimal totalBuyValue = currentBuyOrder.getPrice().multiply(currentBuyOrder.getVolume());
//
//                        // 计算总手续费
//                        BigDecimal totalFees = totalSellValue.multiply(tradeFeeRate).add(totalBuyValue.multiply(tradeFeeRate));
//
//                        // 计算净利润（单位：USDT）
//                        BigDecimal profit = totalSellValue.subtract(totalBuyValue).subtract(totalFees);
//
//                        if (profit.compareTo(BigDecimal.ZERO) > 0) {
//                            log.info("本周期实现净利润: {} USDT, 将用于买入更多币", profit.setScale(10, RoundingMode.DOWN));
//
//                            BigDecimal lastestPrice = apiService.queryLastPrice(instId);
//                            BigDecimal reinvestVolume = profit.divide(lastestPrice, volumeScale, RoundingMode.DOWN);
//
//                            if (reinvestVolume.compareTo(BigDecimal.ZERO) > 0) {
//                                // 挂一个市价买单来再投资利润，确保快速成交
//                                apiService.placeOrder(instId, Side.buy, reinvestVolume, lastestPrice);
//                                log.info("已挂单买入 {} 个币用于再投资利润", reinvestVolume);
//                            }
//                        } else {
//                            log.info("本周期没有实现净利润，不进行再投资");
//                        }
//                        // ==================================
//
//                        // 重置所有状态，开始新的周期
//                        resetState(book);
//
//                        // 撤销旧卖单，因为买单成交意味着价格下跌，之前的卖单已经不合理了
//                        apiService.cancelOrder(instId, book.currentSellOrder.getOrdId());
//                        book.currentSellOrder = null;
//                        book.currentBuyOrder = null; // 清空买单，完成一个买入周期
//                    }
//                }
//
//                // ==============================
//                // 2. 检查卖单状态，如果卖单为空或已成交，则需要重新挂单
//                // ==============================
//                if (book.currentSellOrder == null || OrderState.filled.name().equals(apiService.queryOrderStatus(instId, book.currentSellOrder.getOrdId()))) {
//                    // 区分是“卖单成交”还是“买单成交后”的新一轮循环
//                    if (book.currentSellOrder != null) {
//                        // 这是一个真实的卖单成交
//                        TradeRecord sell = new TradeRecord();
//                        sell.price = book.currentSellOrder.getPrice();
//                        sell.volume = book.currentSellOrder.getVolume();
//                        book.sellHistory.add(sell);
//                        sellCount++; // 卖单成交后，卖出轮次加1
//
//                        // 撤销旧买单
//                        if (book.currentBuyOrder != null) {
//                            apiService.cancelOrder(instId, book.currentBuyOrder.getOrdId());
//                            book.currentBuyOrder = null;
//                        }
//                    }
//
//                    // ==============================
//                    // 3. 计算下一轮真实卖单
//                    // ==============================
//                    // 根据连续卖出次数，计算马丁格尔倍数
//                    BigDecimal volumeMultiple = MathCalculationUtil.pow(volumeMartin, BigDecimal.valueOf(sellCount), 10);
//                    BigDecimal priceMultiple = MathCalculationUtil.pow(priceMartin, BigDecimal.valueOf(sellCount), 10);
//
//                    // 获取当前最新价格作为新卖单的基准价格
//                    BigDecimal basePrice = book.sellHistory.isEmpty() ? apiService.queryLastPrice(instId) :
//                            book.sellHistory.stream()
//                                    .map(t -> t.getPrice().multiply(t.getVolume()))
//                                    .reduce(BigDecimal.ZERO, BigDecimal::add)
//                                    .divide(book.sellHistory.stream()
//                                            .map(TradeRecord::getVolume)
//                                            .reduce(BigDecimal.ZERO, BigDecimal::add), priceScale, RoundingMode.HALF_UP);
//                    log.info("当前已卖出轮次:{},当前卖出基准价:{}", sellCount, basePrice);
//
//                    // 重新计算下一轮卖单价格
//                    BigDecimal nextSellPrice = basePrice.multiply(BigDecimal.ONE.add(step.multiply(priceMultiple)))
//                            .setScale(priceScale, RoundingMode.HALF_UP);
//
//                    // 重新计算卖出量
//                    BigDecimal martinVolume = tradeVolume.multiply(volumeMultiple)
//                            .setScale(volumeScale, RoundingMode.DOWN);
//
//                    // 当前持仓量
//                    BigDecimal holdVolume = apiService.queryAccountBalance(instId.replace("-USDT", ""));
//                    BigDecimal sellVolume;
//                    if (martinVolume.compareTo(holdVolume) > 0) {
//                        log.error("卖飞,以最后的持仓量全部卖出,当前持仓量:{},马丁卖出量:{}", holdVolume, martinVolume);
//                        sellVolume = holdVolume;
//                    } else {
//                        sellVolume = martinVolume;
//                    }
//
//                    // 挂新的真实卖单
//                    book.currentSellOrder = apiService.placeOrder(instId, Side.sell, sellVolume, nextSellPrice);
//
//                    // ==============================
//                    // 4. 计算买回量并挂单
//                    // ==============================
//                    // 在有卖出历史记录时，计算买单并挂单
//                    if (sellCount > 0) {
//                        BigDecimal totalRealSellVolume = book.sellHistory.stream()
//                                .map(TradeRecord::getVolume)
//                                .reduce(BigDecimal.ZERO, BigDecimal::add);
//
//                        BigDecimal buyVolume = totalRealSellVolume;
//                        BigDecimal buyPrice = basePrice.multiply(BigDecimal.ONE.subtract(step))
//                                .setScale(priceScale, RoundingMode.HALF_UP);
//
//                        if (buyVolume.compareTo(BigDecimal.ZERO) > 0) {
//                            book.currentBuyOrder = apiService.placeOrder(instId, Side.buy, buyVolume, buyPrice);
//                        } else {
//                            log.info("买入量为0或负数，无需挂买单。buyVolume: {}", buyVolume);
//                            book.currentBuyOrder = null;
//                        }
//                    }
//                }
//
//                Thread.sleep(2000); // 每2秒检查一次订单状态
//            } catch (Exception e) {
//                log.error("循环中异常", e);
//            }
//        }
//    }
//
//    // 私有方法，用于在买单成交后重置所有状态
//    private void resetState(OrderBook book) {
//        sellCount = 0;
//        book.sellHistory.clear();
//    }
//}
